
<!DOCTYPE html>

<html>
  
<!-- Mirrored from docs.sympy.org/latest/modules/physics/mechanics/symsystem.html by HTTrack Website Copier/3.x [XR&CO'2014], Sat, 15 Jan 2022 03:28:36 GMT -->
<!-- Added by HTTrack --><meta http-equiv="content-type" content="text/html;charset=utf-8" /><!-- /Added by HTTrack -->
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />

    <title>Symbolic Systems in Physics/Mechanics &#8212; SymPy 1.9 documentation</title>
    <link rel="stylesheet" type="text/css" href="../../../_static/pygments.css" />
    <link rel="stylesheet" type="text/css" href="../../../_static/default.css" />
    <link rel="stylesheet" type="text/css" href="../../../_static/graphviz.css" />
    <link rel="stylesheet" type="text/css" href="../../../_static/plot_directive.css" />
    <link rel="stylesheet" type="text/css" href="../../../../../live.sympy.org/static/live-core.css" />
    <link rel="stylesheet" type="text/css" href="../../../../../live.sympy.org/static/live-autocomplete.css" />
    <link rel="stylesheet" type="text/css" href="../../../../../live.sympy.org/static/live-sphinx.css" />
    
    <script data-url_root="../../../" id="documentation_options" src="../../../_static/documentation_options.js"></script>
    <script src="../../../_static/jquery.js"></script>
    <script src="../../../_static/underscore.js"></script>
    <script src="../../../_static/doctools.js"></script>
    <script src="../../../../../live.sympy.org/static/utilities.js"></script>
    <script src="../../../../../live.sympy.org/static/external/classy.js"></script>
    <script src="../../../../../live.sympy.org/static/live-core.js"></script>
    <script src="../../../../../live.sympy.org/static/live-autocomplete.js"></script>
    <script src="../../../../../live.sympy.org/static/live-sphinx.js"></script>
    <script async="async" src="../../../../../cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest8331.js?config=TeX-AMS_HTML-full"></script>
    <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["\\(", "\\)"]], "displayMath": [["\\[", "\\]"]]}})</script>
    
    <link rel="shortcut icon" href="../../../_static/sympy-notailtext-favicon.ico"/>
    <link href="symsystem.html" rel="canonical" />
    
    <link rel="index" title="Index" href="../../../genindex.html" />
    <link rel="search" title="Search" href="../../../search.html" />
    <link rel="next" title="Linearization in Physics/Mechanics" href="linearize.html" />
    <link rel="prev" title="Lagrange’s Method in Physics/Mechanics" href="lagrange.html" /> 
  </head><body>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../../../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="../../../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="linearize.html" title="Linearization in Physics/Mechanics"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="lagrange.html" title="Lagrange’s Method in Physics/Mechanics"
             accesskey="P">previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="../../../index.html">SymPy 1.9 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="../../index.html" >SymPy Modules Reference</a> &#187;</li>
          <li class="nav-item nav-item-2"><a href="../index.html" >Physics</a> &#187;</li>
          <li class="nav-item nav-item-3"><a href="index.html" accesskey="U">Classical Mechanics</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="#">Symbolic Systems in Physics/Mechanics</a></li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <section id="symbolic-systems-in-physics-mechanics">
<h1>Symbolic Systems in Physics/Mechanics<a class="headerlink" href="#symbolic-systems-in-physics-mechanics" title="Permalink to this headline">¶</a></h1>
<p>The <span class="math notranslate nohighlight">\(SymbolicSystem\)</span> class in physics/mechanics is a location for the pertinent
information of a multibody dynamic system. In its most basic form it contains
the equations of motion for the dynamic system, however, it can also contain
information regarding the loads that the system is subject to, the bodies that
the system is comprised of and any additional equations the user feels is
important for the system. The goal of this class is to provide a unified output
format for the equations of motion that numerical analysis code can be designed
around.</p>
<section id="symbolicsystem-example-usage">
<h2>SymbolicSystem Example Usage<a class="headerlink" href="#symbolicsystem-example-usage" title="Permalink to this headline">¶</a></h2>
<p>This code will go over the manual input of the equations of motion for the
simple pendulum that uses the Cartesian location of the mass as the generalized
coordinates into <span class="math notranslate nohighlight">\(SymbolicSystem\)</span>.</p>
<p>The equations of motion are formed in the physics/mechanics/<a class="reference external" href="../examples/lin_pend_nonmin_example.html">examples</a>. In that
spot the variables q1 and q2 are used in place of x and y and the reference
frame is rotated 90 degrees.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy</span> <span class="kn">import</span> <span class="n">atan</span><span class="p">,</span> <span class="n">symbols</span><span class="p">,</span> <span class="n">Matrix</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.mechanics</span> <span class="kn">import</span> <span class="p">(</span><span class="n">dynamicsymbols</span><span class="p">,</span> <span class="n">ReferenceFrame</span><span class="p">,</span>
<span class="gp">... </span>                                     <span class="n">Particle</span><span class="p">,</span> <span class="n">Point</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">sympy.physics.mechanics.system</span> <span class="k">as</span> <span class="nn">system</span>
<span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">sympy.physics.vector</span> <span class="kn">import</span> <span class="n">init_vprinting</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">init_vprinting</span><span class="p">(</span><span class="n">pretty_print</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
</pre></div>
</div>
<p>The first step will be to initialize all of the dynamic and constant symbols.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">lam</span> <span class="o">=</span> <span class="n">dynamicsymbols</span><span class="p">(</span><span class="s1">&#39;x y u v lambda&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">m</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">g</span> <span class="o">=</span> <span class="n">symbols</span><span class="p">(</span><span class="s1">&#39;m l g&#39;</span><span class="p">)</span>
</pre></div>
</div>
<p>Next step is to define the equations of motion in multiple forms:</p>
<blockquote>
<div><dl class="simple">
<dt>[1] Explicit form where the kinematics and dynamics are combined</dt><dd><p>x’ = F_1(x, t, r, p)</p>
</dd>
<dt>[2] Implicit form where the kinematics and dynamics are combined</dt><dd><p>M_2(x, p) x’ = F_2(x, t, r, p)</p>
</dd>
<dt>[3] Implicit form where the kinematics and dynamics are separate</dt><dd><p>M_3(q, p) u’ = F_3(q, u, t, r, p)
q’ = G(q, u, t, r, p)</p>
</dd>
</dl>
</div></blockquote>
<p>where</p>
<blockquote>
<div><p>x : states, e.g. [q, u]
t : time
r : specified (exogenous) inputs
p : constants
q : generalized coordinates
u : generalized speeds
F_1 : right hand side of the combined equations in explicit form
F_2 : right hand side of the combined equations in implicit form
F_3 : right hand side of the dynamical equations in implicit form
M_2 : mass matrix of the combined equations in implicit form
M_3 : mass matrix of the dynamical equations in implicit form
G : right hand side of the kinematical differential equations</p>
</div></blockquote>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">dyn_implicit_mat</span> <span class="o">=</span> <span class="n">Matrix</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="n">x</span><span class="o">/</span><span class="n">m</span><span class="p">],</span>
<span class="gp">... </span>                           <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="n">y</span><span class="o">/</span><span class="n">m</span><span class="p">],</span>
<span class="gp">... </span>                           <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">l</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="n">m</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">dyn_implicit_rhs</span> <span class="o">=</span> <span class="n">Matrix</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">u</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="n">v</span><span class="o">**</span><span class="mi">2</span> <span class="o">-</span> <span class="n">g</span><span class="o">*</span><span class="n">y</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">comb_implicit_mat</span> <span class="o">=</span> <span class="n">Matrix</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
<span class="gp">... </span>                            <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
<span class="gp">... </span>                            <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="n">x</span><span class="o">/</span><span class="n">m</span><span class="p">],</span>
<span class="gp">... </span>                            <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="n">y</span><span class="o">/</span><span class="n">m</span><span class="p">],</span>
<span class="gp">... </span>                            <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">l</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="n">m</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">comb_implicit_rhs</span> <span class="o">=</span> <span class="n">Matrix</span><span class="p">([</span><span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">u</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="n">v</span><span class="o">**</span><span class="mi">2</span> <span class="o">-</span> <span class="n">g</span><span class="o">*</span><span class="n">y</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">kin_explicit_rhs</span> <span class="o">=</span> <span class="n">Matrix</span><span class="p">([</span><span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">comb_explicit_rhs</span> <span class="o">=</span> <span class="n">comb_implicit_mat</span><span class="o">.</span><span class="n">LUsolve</span><span class="p">(</span><span class="n">comb_implicit_rhs</span><span class="p">)</span>
</pre></div>
</div>
<p>Now the reference frames, points and particles will be set up so this
information can be passed into <span class="math notranslate nohighlight">\(system.SymbolicSystem\)</span> in the form of a bodies
and loads iterable.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">theta</span> <span class="o">=</span> <span class="n">atan</span><span class="p">(</span><span class="n">x</span><span class="o">/</span><span class="n">y</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">omega</span> <span class="o">=</span> <span class="n">dynamicsymbols</span><span class="p">(</span><span class="s1">&#39;omega&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">N</span> <span class="o">=</span> <span class="n">ReferenceFrame</span><span class="p">(</span><span class="s1">&#39;N&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">N</span><span class="o">.</span><span class="n">orientnew</span><span class="p">(</span><span class="s1">&#39;A&#39;</span><span class="p">,</span> <span class="s1">&#39;Axis&#39;</span><span class="p">,</span> <span class="p">[</span><span class="n">theta</span><span class="p">,</span> <span class="n">N</span><span class="o">.</span><span class="n">z</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span><span class="o">.</span><span class="n">set_ang_vel</span><span class="p">(</span><span class="n">N</span><span class="p">,</span> <span class="n">omega</span> <span class="o">*</span> <span class="n">N</span><span class="o">.</span><span class="n">z</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">O</span> <span class="o">=</span> <span class="n">Point</span><span class="p">(</span><span class="s1">&#39;O&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">O</span><span class="o">.</span><span class="n">set_vel</span><span class="p">(</span><span class="n">N</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">P</span> <span class="o">=</span> <span class="n">O</span><span class="o">.</span><span class="n">locatenew</span><span class="p">(</span><span class="s1">&#39;P&#39;</span><span class="p">,</span> <span class="n">l</span> <span class="o">*</span> <span class="n">A</span><span class="o">.</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">P</span><span class="o">.</span><span class="n">v2pt_theory</span><span class="p">(</span><span class="n">O</span><span class="p">,</span> <span class="n">N</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="go">l*omega*A.y</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">Pa</span> <span class="o">=</span> <span class="n">Particle</span><span class="p">(</span><span class="s1">&#39;Pa&#39;</span><span class="p">,</span> <span class="n">P</span><span class="p">,</span> <span class="n">m</span><span class="p">)</span>
</pre></div>
</div>
<p>Now the bodies and loads iterables need to be initialized.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">bodies</span> <span class="o">=</span> <span class="p">[</span><span class="n">Pa</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">loads</span> <span class="o">=</span> <span class="p">[(</span><span class="n">P</span><span class="p">,</span> <span class="n">g</span> <span class="o">*</span> <span class="n">m</span> <span class="o">*</span> <span class="n">N</span><span class="o">.</span><span class="n">x</span><span class="p">)]</span>
</pre></div>
</div>
<p>The equations of motion are in the form of a differential algebraic equation
(DAE) and DAE solvers need to know which of the equations are the algebraic
expressions. This information is passed into <span class="math notranslate nohighlight">\(SymbolicSystem\)</span> as a list
specifying which rows are the algebraic equations. In this example it is a
different row based on the chosen equations of motion format. The row index
should always correspond to the mass matrix that is being input to the
<span class="math notranslate nohighlight">\(SymbolicSystem\)</span> class but will always correspond to the row index of the
combined dynamics and kinematics when being accessed from the <span class="math notranslate nohighlight">\(SymbolicSystem\)</span>
class.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">alg_con</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">alg_con_full</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">]</span>
</pre></div>
</div>
<p>An iterable containing the states now needs to be created for the system. The
<span class="math notranslate nohighlight">\(SymbolicSystem\)</span> class can determine which of the states are considered
coordinates or speeds by passing in the indexes of the coordinates and speeds.
If these indexes are not passed in the object will not be able to differentiate
between coordinates and speeds.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">states</span> <span class="o">=</span> <span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">u</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="n">lam</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">coord_idxs</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">speed_idxs</span> <span class="o">=</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
</pre></div>
</div>
<p>Now the equations of motion instances can be created using the above mentioned
equations of motion formats.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>   &gt;&gt;&gt; symsystem1 = system.SymbolicSystem(states, comb_explicit_rhs,
   ...                                    alg_con=alg_con_full, bodies=bodies,
   ...                                    loads=loads)
   &gt;&gt;&gt; symsystem2 = system.SymbolicSystem(states, comb_implicit_rhs,
   ...                                    mass_matrix=comb_implicit_mat,
   ...                                    alg_con=alg_con_full,
   ...                                    coord_idxs=coord_idxs)
   &gt;&gt;&gt; symsystem3 = system.SymbolicSystem(states, dyn_implicit_rhs,
   ...                                    mass_matrix=dyn_implicit_mat,
   ...                                    coordinate_derivatives=kin_explicit_rhs,
   ...                                    alg_con=alg_con,
   ...                                    coord_idxs=coord_idxs,
   ...                                    speed_idxs=speed_idxs)

Like coordinates and speeds, the bodies and loads attributes can only be
accessed if they are specified during initialization of the `SymbolicSystem`
class. Lastly here are some attributes accessible from the `SymbolicSystem`
class. ::

   &gt;&gt;&gt; symsystem1.states
   Matrix([
   [     x],
   [     y],
   [     u],
   [     v],
   [lambda]])
   &gt;&gt;&gt; symsystem2.coordinates
   Matrix([
   [x],
   [y]])
   &gt;&gt;&gt; symsystem3.speeds
   Matrix([
   [u],
   [v]])
   &gt;&gt;&gt; symsystem1.comb_explicit_rhs
   Matrix([
   [                          u],
   [                          v],
   [(-g*y + u**2 + v**2)*x/l**2],
   [(-g*y + u**2 + v**2)*y/l**2],
   [m*(-g*y + u**2 + v**2)/l**2]])
   &gt;&gt;&gt; symsystem2.comb_implicit_rhs
   Matrix([
   [                 u],
   [                 v],
   [                 0],
   [                 0],
   [-g*y + u**2 + v**2]])
   &gt;&gt;&gt; symsystem2.comb_implicit_mat
   Matrix([
   [1, 0, 0, 0,      0],
   [0, 1, 0, 0,      0],
   [0, 0, 1, 0,   -x/m],
   [0, 0, 0, 1,   -y/m],
   [0, 0, 0, 0, l**2/m]])
   &gt;&gt;&gt; symsystem3.dyn_implicit_rhs
   Matrix([
   [                 0],
   [                 0],
   [-g*y + u**2 + v**2]])
   &gt;&gt;&gt; symsystem3.dyn_implicit_mat
   Matrix([
   [1, 0,   -x/m],
   [0, 1,   -y/m],
   [0, 0, l**2/m]])
   &gt;&gt;&gt; symsystem3.kin_explicit_rhs
   Matrix([
   [u],
   [v]])
   &gt;&gt;&gt; symsystem1.alg_con
   [4]
   &gt;&gt;&gt; symsystem1.bodies
   (Pa,)
   &gt;&gt;&gt; symsystem1.loads
   ((P, g*m*N.x),)
</pre></div>
</div>
</section>
</section>


            <div class="clearer"></div>
          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
            <p class="logo"><a href="../../../index.html">
              <img class="logo" src="../../../_static/sympylogo.png" alt="Logo"/>
            </a></p>
  <h3><a href="../../../index.html">Table of Contents</a></h3>
  <ul>
<li><a class="reference internal" href="#">Symbolic Systems in Physics/Mechanics</a><ul>
<li><a class="reference internal" href="#symbolicsystem-example-usage">SymbolicSystem Example Usage</a></li>
</ul>
</li>
</ul>

  <h4>Previous topic</h4>
  <p class="topless"><a href="lagrange.html"
                        title="previous chapter">Lagrange’s Method in Physics/Mechanics</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="linearize.html"
                        title="next chapter">Linearization in Physics/Mechanics</a></p>
  <div role="note" aria-label="source link">
    <h3>This Page</h3>
    <ul class="this-page-menu">
      <li><a href="../../../_sources/modules/physics/mechanics/symsystem.rst.txt"
            rel="nofollow">Show Source</a></li>
    </ul>
   </div>
<div id="searchbox" style="display: none" role="search">
  <h3 id="searchlabel">Quick search</h3>
    <div class="searchformwrapper">
    <form class="search" action="https://docs.sympy.org/latest/search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
      <input type="submit" value="Go" />
    </form>
    </div>
</div>
<script>$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../../../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="../../../py-modindex.html" title="Python Module Index"
             >modules</a> |</li>
        <li class="right" >
          <a href="linearize.html" title="Linearization in Physics/Mechanics"
             >next</a> |</li>
        <li class="right" >
          <a href="lagrange.html" title="Lagrange’s Method in Physics/Mechanics"
             >previous</a> |</li>
        <li class="nav-item nav-item-0"><a href="../../../index.html">SymPy 1.9 documentation</a> &#187;</li>
          <li class="nav-item nav-item-1"><a href="../../index.html" >SymPy Modules Reference</a> &#187;</li>
          <li class="nav-item nav-item-2"><a href="../index.html" >Physics</a> &#187;</li>
          <li class="nav-item nav-item-3"><a href="index.html" >Classical Mechanics</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="#">Symbolic Systems in Physics/Mechanics</a></li> 
      </ul>
    </div>
    <div class="footer" role="contentinfo">
        &#169; Copyright 2021 SymPy Development Team.
      Last updated on Sep 30, 2021.
      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.1.2.
    </div>
  </body>

<!-- Mirrored from docs.sympy.org/latest/modules/physics/mechanics/symsystem.html by HTTrack Website Copier/3.x [XR&CO'2014], Sat, 15 Jan 2022 03:28:37 GMT -->
</html>